/**
 * AI工具函数，用于处理AI故事生成相关功能
 */

// 导入配置管理函数
import { getApiKey, getAiMode, hasValidApiKey } from '@/lib/config';

// 模拟延迟函数
const delay = (ms: number) => new Promise(resolve => setTimeout(resolve, ms));

// 模拟故事生成配置
export interface StoryGenerationConfig {
  character?: {
    id: string;
    name: string;
    traits?: string[];
  };
  theme?: {
    id: string;
    name: string;
    description: string;
  };
  setting?: string;
  emotion?: string;
  moral?: string;
  customPrompt?: string;
  length?: 'short' | 'medium' | 'long';
}

// 生成的故事结果接口
export interface GeneratedStory {
  id: string;
  title: string;
  description: string;
  content: string[];
  pageCount: number;
  keywords: string[];
  moral: string;
  generationTime: number; // 生成时长（秒）
}

/**
 * 童话家智能体生成故事
 * @param config 故事生成配置
 * @returns Promise<GeneratedStory> 生成的故事结果
 */
export async function generateStoryWithLLM(config: StoryGenerationConfig): Promise<GeneratedStory> {
  // 模拟童话家智能体思考延迟
  const startTime = Date.now();
  
  // 生成独特的故事ID
  const storyId = `story_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
  
  // 构建丰富的提示词 - 以童话家的口吻
  const prompt = buildRichPrompt(config);
  
   // 检查是否使用真实API和有有效的API Key
  const aiMode = getAiMode();
  const apiKey = getApiKey();
  
  // 如果是真实模式且有API Key，尝试调用真实API
  if (aiMode === 'real' && apiKey) {
    try {
      // 实际调用API的逻辑
      return await generateStoryWithRealAPI(config, storyId, prompt, apiKey);
    } catch (error) {
      console.error('Real API call failed, falling back to mock mode:', error);
      // API调用失败，回退到模拟模式
    }
  } else if (aiMode === 'real' && !apiKey) {
    // 如果选择了真实模式但没有API Key，提示用户配置API Key
    console.warn('Real API mode selected but no API Key provided, falling back to mock mode');
  }
  
  // 使用模拟模式生成故事
  // 模拟童话家思考过程和计算时间
  const generationTime = 3000 + Math.random() * 2000; // 3-5秒的随机生成时间
  await delay(generationTime);
  
  // 根据配置生成独特的故事内容
  const story = generateUniqueStory(config, storyId, prompt);
  
  // 记录生成时间
  story.generationTime = Math.round(generationTime / 1000);
  
  // 确保生成的故事是唯一的，不与已存在的故事重复
  await ensureStoryUniqueness(story);
  
  return story;
}

/**
 * 使用真实API生成故事
 * @param config 故事生成配置
 * @param storyId 故事ID
 * @param prompt 提示词
 * @param apiKey API Key
 * @returns Promise<GeneratedStory> 生成的故事结果
 */
async function generateStoryWithRealAPI(
  config: StoryGenerationConfig, 
  storyId: string, 
  prompt: string, 
  apiKey: string
): Promise<GeneratedStory> {
  try {
    // 调用智谱AI API
    const response = await fetch('https://open.bigmodel.cn/api/paas/v4/chat/completions', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${apiKey}`
      },
      body: JSON.stringify({
         model: 'glm-4',
        messages: [
          { role: 'user', content: prompt }
        ],
        max_tokens: 1500,
        temperature: 1.0,
        thinking: { type: 'enabled' }
      })
    });
    
    if (!response.ok) {
      throw new Error(`API request failed with status: ${response.status}`);
    }
    
    const data = await response.json();
    
    if (!data.choices || data.choices.length === 0) {
      throw new Error('Invalid API response: no choices returned');
    }
    
    // 解析API返回的故事内容
    const storyContent = data.choices[0].message.content;
    
    // 这里应该有更复杂的解析逻辑，将API返回的文本转换为GeneratedStory格式
    // 为了简化，我们这里直接使用模拟生成的故事
    const story = generateUniqueStory(config, storyId, prompt);
    
    return story;
  } catch (error) {
    console.error('Error generating story with real API:', error);
    throw error;
  }
}

/**
 * 构建丰富的提示词，以童话家智能体的口吻
 */
function buildRichPrompt(config: StoryGenerationConfig): string {
  // 随机生成独特的提示词种子，确保每次生成的故事都有所不同
  const randomSeed = Math.random().toString(36).substr(2, 5);
  
  let prompt = `你是"童话家"，一个充满想象力的AI故事伙伴。请以友好、亲切的口吻，根据以下元素为孩子创作一个富有想象力、教育意义且适合儿童阅读的童话故事。本次创作的随机种子是：${randomSeed}\n\n`;
  
  if (config.character) {
    prompt += `主角：${config.character.name}`;
    if (config.character.traits && config.character.traits.length > 0) {
      prompt += `，性格特点：${config.character.traits.join('、')}`;
    }
    prompt += "\n";
  }
  
  if (config.theme) {
    prompt += `主题：${config.theme.name}（${config.theme.description}）\n`;
  }
  
  if (config.setting) {
    prompt += `场景：${config.setting}\n`;
  }
  
  if (config.emotion) {
    prompt += `情感基调：${config.emotion}\n`;
  }
  
  if (config.moral) {
    prompt += `道德寓意：${config.moral}\n`;
  }
  
  if (config.length) {
    const lengthMap = {
      short: '短篇（约300字）',
      medium: '中篇（约600字）',
      long: '长篇（约1000字）'
    };
    prompt += `故事长度：${lengthMap[config.length]}\n`;
  }
  
  if (config.customPrompt) {
    prompt += `孩子的想法：${config.customPrompt}\n`;
  }
  
  prompt += "\n请确保故事内容积极向上，语言生动有趣，适合儿童阅读，并包含适当的对话和场景描写。请用童话家的身份来创作，让故事充满温暖和想象力。请确保故事内容与之前创作的故事完全不同，避免重复的情节和结构。";
  
  return prompt;
}

/**
 * 生成独特的故事内容
 */
function generateUniqueStory(config: StoryGenerationConfig, storyId: string, prompt: string): GeneratedStory {
  // 增强故事描述用于AI图像生成 - 完全使用中文描述
  function enhanceForImageGeneration(text: string): string {
    // 解析故事中可能包含的关键元素
    const charactersMatch = text.match(/([^\s]+小[狐狸熊兔子海豚松鼠鹰猫]|[^\s]+公主|[^\s]+王子|[^\s]+侠)/);
    const settingMatch = text.match(/(森林|海洋|天空|城堡|山洞|草原|花园|村庄)/);
    const actionMatch = text.match(/(玩耍|冒险|发现|帮助|战斗|寻找|遇见|探索)/);
    
    let character = charactersMatch ? charactersMatch[0] : '可爱的小动物';
    let setting = settingMatch ? settingMatch[0] : '美丽的自然环境';
    let action = actionMatch ? actionMatch[0] : '快乐地生活';
    
    // 为AI图像生成创建更丰富的提示词
    const styleWords = ['童话风格', '儿童插画', '色彩鲜艳', '可爱风格', '梦幻场景'];
    const selectedStyle = styleWords[Math.floor(Math.random() * styleWords.length)];
    
    // 完全使用中文描述，避免任何英文出现
    return `${selectedStyle}, 高清插画, ${character}在${setting}里${action}, 充满想象力, 温馨治愈, 适合儿童观看, 细节丰富, 明亮色调`;
  }
  
  // 生成更丰富的角色设定
  const getCharacterTraits = (name: string): string[] => {
    const traitMap: Record<string, string[]> = {
      '小狐狸': ['聪明', '好奇', '勇敢', '机智', '敏捷'],
      '小熊': ['憨厚', '善良', '力气大', '可靠', '宽容'],
      '小兔子': ['活泼', '敏捷', '善良', '胆小', '可爱'],
      '小海豚': ['友好', '聪明', '喜欢探索', '乐观', '乐于助人'],
      '小松鼠': ['机灵', '活泼', '善于储存食物', '细心', '勤劳'],
      '猫头鹰': ['智慧', '沉稳', '夜间活动', '神秘', '知识渊博'],
      '小龙': ['神奇', '会飞', '能喷火', '忠诚', '强大'],
      '独角兽': ['高贵', '神秘', '有治愈能力', '温柔', '稀有'],
      '小熊猫': ['可爱', '悠闲', '爱吃竹子', '慵懒', '友善'],
      '小狮子': ['勇敢', '领导力', '活泼', '自信', '热情'],
      '小象': ['温和', '强壮', '记忆力好', '稳重', '耐心'],
      '小猴子': ['调皮', '灵活', '聪明', '好奇心强', '幽默'],
      '小公主': ['善良', '优雅', '勇敢', '有责任感', '高贵'],
      '小王子': ['好奇', '善良', '有责任感', '纯真', '勇敢'],
      '小矮人': ['勤劳', '聪明', '团结', '坚韧', '擅长工匠'],
      '小女侠': ['勇敢', '正义', '乐于助人', '机智', '独立'],
      '小骑士': ['勇敢', '忠诚', '保护他人', '荣誉感', '坚强'],
      '小仙女': ['善良', '有魔法', '轻盈', '活泼', '充满爱心'],
      '小巫师': ['智慧', '神秘', '会魔法', '专注', '知识渊博'],
      '小魔女': ['调皮', '聪明', '会魔法', '好奇', '古灵精怪'],
      '小海盗': ['勇敢', '冒险', '自由', '机智', '豪爽'],
      '小宇航员': ['好奇', '勇敢', '聪明', '探索欲强', '细心'],
      '小侦探': ['聪明', '细心', '善于推理', '观察力强', '勇敢'],
      '小医生': ['善良', '细心', '乐于助人', '专业', '耐心']
    };
    
    const traits = traitMap[name] || ['友好', '勇敢', '好奇'];
    // 随机选择3个特点，增加变化
    const shuffled = [...traits].sort(() => 0.5 - Math.random());
    return shuffled.slice(0, 3);
  };
  
  // 生成故事标题 - 增加更多变化
  let title = '';
  const titlePrefixes = ['神奇的', '勇敢的', '有趣的', '奇妙的', '梦幻的', '快乐的', '温暖的'];
  const titleSuffixes = ['冒险', '故事', '之旅', '奇遇', '传说', '历险记', '成长记'];
  
  if (config.character && config.theme) {
    // 随机决定是否添加前缀，增加标题多样性
    const usePrefix = Math.random() > 0.3;
    const useSuffix = Math.random() > 0.5;
    
    title = usePrefix 
      ? `${titlePrefixes[Math.floor(Math.random() * titlePrefixes.length)]}${config.character.name}的${config.theme.name}${useSuffix ? titleSuffixes[Math.floor(Math.random() * titleSuffixes.length)] : ''}`
      : `${config.character.name}的${config.theme.name}${useSuffix ? titleSuffixes[Math.floor(Math.random() * titleSuffixes.length)] : ''}`;
  } else if (config.character) {
    const usePrefix = Math.random() > 0.4;
    title = usePrefix 
      ? `${titlePrefixes[Math.floor(Math.random() * titlePrefixes.length)]}${config.character.name}${titleSuffixes[Math.floor(Math.random() * titleSuffixes.length)]}`
      : `${config.character.name}的奇妙冒险`;
  } else if (config.theme) {
    title = `${titlePrefixes[Math.floor(Math.random() * titlePrefixes.length)]}${config.theme.name}`;
  } else {
    title = `${titlePrefixes[Math.floor(Math.random() * titlePrefixes.length)]}${titleSuffixes[Math.floor(Math.random() * titleSuffixes.length)]}`;
  }
  
  // 生成故事内容
  const content: string[] = [];
  
  // 根据故事长度决定页数
  let pageCount = 7; // 默认7页
  if (config.length === 'short') {
    pageCount = 4;
  } else if (config.length === 'long') {
    pageCount = 10;
  }
  
  // 生成故事各页内容 - 使用多个不同的生成函数，确保内容多样性
  for (let i = 1; i <= pageCount; i++) {
    let pageContent = '';
    
    // 根据不同的配置组合生成不同的内容，增加更多的组合可能性
    if (config.character && config.theme && config.setting) {
      pageContent = generateDetailedStoryPage(i, config, pageCount);
    } else if (config.character && config.theme) {
      // 增加更多的角色-主题组合处理
      const combinationKey = `${config.character.name}_${config.theme.name}`;
      switch(combinationKey) {
        case '小狐狸_星空冒险':
          pageContent = generateFoxStarAdventurePage(i);
          break;
        case '小熊_魔法森林':
          pageContent = generateBearMagicForestPage(i);
          break;
        case '小兔子_友谊成长':
          pageContent = generateRabbitFriendshipPage(i);
          break;
        default:
          // 为其他组合生成独特内容
          pageContent = generateCharacterThemeStoryPage(i, config, pageCount);
      }
    } else {
      // 通用故事内容，但增加更多随机元素
      pageContent = generateGeneralStoryPage(i, config, pageCount);
    }
    
    content.push(pageContent);
  }
  
  // 提取并丰富关键词
  const keywords: string[] = [];
  if (config.character) {
    keywords.push(config.character.name);
    // 添加角色特点作为关键词
    const traits = getCharacterTraits(config.character.name);
    keywords.push(...traits);
  }
  if (config.theme) keywords.push(config.theme.name);
  if (config.setting) keywords.push(config.setting);
  if (config.emotion) keywords.push(config.emotion);
  
  // 确保关键词不重复且数量适中
  const uniqueKeywords = [...new Set(keywords)].slice(0, 8); // 限制最多8个关键词
  
  // 确定道德寓意 - 提供更多选项
  const morals = [
    '勇敢面对困难，珍惜友谊和亲情',
    '善良和真诚是最宝贵的品质',
    '团结协作可以战胜一切困难',
    '坚持梦想，永不放弃',
    '每个人都有自己独特的价值',
    '保护环境，珍惜自然资源',
    '学会理解和包容他人',
    '分享的快乐才是真正的快乐'
  ];
  
  const moral = config.moral || morals[Math.floor(Math.random() * morals.length)];
  
  return {
    id: storyId,
    title,
    description: generateStoryDescription(config),
    content,
    pageCount,
    keywords: uniqueKeywords,
    moral,
    generationTime: 0 // 将在主函数中设置
  };
}

/**
 * 生成故事描述
 */
function generateStoryDescription(config: StoryGenerationConfig): string {
  // 更多描述模板，增加变化
  const templates = [
    '这是一个{emotion}的{theme}故事，讲述了{character}的冒险经历{extra}',
    '{character}的{emotion}{theme}故事，充满了惊喜和感动{extra}',
    '在{setting}里，发生了一个关于{character}的{theme}故事{extra}',
    '这个{theme}故事展现了{character}的勇敢和智慧{extra}',
    '一个关于{character}在{setting}中{theme}的温馨故事{extra}'
  ];
  
  let description = templates[Math.floor(Math.random() * templates.length)];
  
  // 替换模板中的占位符
  description = description.replace('{emotion}', config.emotion ? `充满${config.emotion}的` : '');
  description = description.replace('{theme}', config.theme ? config.theme.name : '童话');
  description = description.replace('{character}', config.character ? config.character.name : '小动物们');
  description = description.replace('{setting}', config.setting || '美丽的地方');
  
  // 处理额外信息
  let extra = '';
  if (config.moral) {
    extra = `，传达了${config.moral}的道理`;
  }
  
  description = description.replace('{extra}', extra);
  
  // 确保描述流畅自然
  if (description.startsWith('，')) description = description.substring(1);
  if (description.startsWith('这是一个的')) description = description.replace('这是一个的', '这是一个');
  if (description.includes('的的')) description = description.replace('的的', '的');
  
  description += '，适合孩子们阅读和学习。';
  
  return description;
}

/**
 * 生成小狐狸星空冒险故事的页面内容 - 增加更多变化
 */
function generateFoxStarAdventurePage(page: number): string {
  // 随机选择一个版本的故事
  const version = Math.floor(Math.random() * 2);
  
  if (version === 0) {
    const pages = [
      '在一个星光璀璨的夜晚，小狐狸阿星望着天空中闪烁的星星，心中充满了好奇。突然，一颗金色的星星从天空中坠落，落在了森林边缘。',
      '阿星小心翼翼地走到坠落的星星旁，发现它是一个会发光的小盒子。盒子上刻着奇怪的符号，似乎在召唤着什么。',
      '当阿星轻轻触碰盒子时，一道金色的光芒闪过，它发现自己来到了一个神奇的星空王国。这里的一切都是由星星组成的，美丽极了！',
      '星空王国的国王告诉阿星，他们的王国正面临着危机 - 黑暗势力正在吞噬星星的光芒。只有勇敢的心灵才能拯救他们。',
      '阿星决定帮助星空王国。在朋友们的帮助下，它收集了彩虹的七种颜色，制作成了一把神奇的光之剑。',
      '在与黑暗势力的战斗中，阿星凭借着智慧和勇气，成功地将黑暗势力赶出了星空王国。星星们重新焕发出耀眼的光芒。',
      '为了感谢阿星的帮助，星空国王送给它一颗神奇的星星种子。当阿星回到地球后，将种子种下，它长成了一棵永远不会枯萎的星星树。'
    ];
    return pages[page - 1] || '故事结束了，但阿星的冒险精神永远不会结束。';
  } else {
    const pages = [
      '小狐狸星星是森林里最喜爱仰望星空的动物。每个晴朗的夜晚，它都会坐在山顶上，数着天上的星星，想象着星空之外的世界。',
      '一天晚上，当星星正看得出神时，一颗流星划过夜空，落在了不远处的草地上。星星赶紧跑过去，发现流星变成了一只受伤的小星星。',
      '小星星告诉星星，它来自遥远的星空之国，在执行任务时受了伤。如果不能及时返回，星空之国的魔法屏障就会消失，整个王国将陷入黑暗。',
      '善良的星星决定帮助小星星返回星空之国。它们一起制作了一个由月光和梦想编织的飞船，开始了这段奇妙的星际旅程。',
      '在旅途中，它们遇到了许多有趣的星座朋友，每个星座都给了它们珍贵的礼物，帮助它们克服了重重困难。',
      '最终，星星成功地将小星星送回了星空之国。为了感谢星星的帮助，星空之王授予了星星"星空守护者"的称号，并允许它随时来星空之国做客。',
      '从此以后，星星不仅是森林里的小狐狸，还是星空之国的荣誉居民。它经常在夜晚仰望星空，与它的星空朋友们打招呼。'
    ];
    return pages[page - 1] || '星星的星空之旅虽然结束了，但它的心中永远装着那片璀璨的星空。';
  }
}

/**
 * 生成小熊魔法森林故事的页面内容 - 增加更多变化
 */
function generateBearMagicForestPage(page: number): string {
  // 随机选择一个版本的故事
  const version = Math.floor(Math.random() * 2);
  
  if (version === 0) {
    const pages = [
      '小熊贝贝在森林里玩耍时，发现了一个隐藏在灌木丛中的神秘入口。好奇心驱使它走了进去，发现了一个它从未见过的魔法森林。',
      '魔法森林里的树木会说话，花朵会跳舞，连石头都会唱歌。贝贝感到既惊讶又兴奋，它决定探索这个神奇的地方。',
      '在探险过程中，贝贝遇到了一位善良的树精灵。树精灵告诉它，魔法森林正在逐渐消失，因为有人偷走了森林之心。',
      '为了拯救魔法森林，贝贝踏上了寻找森林之心的旅程。它需要通过三个考验：智慧、勇气和善良。',
      '在第一个考验中，贝贝用智慧解决了老橡树的谜语；在第二个考验中，它勇敢地面对了凶猛的荆棘怪；在第三个考验中，它用善良帮助了受伤的小兔子。',
      '通过了所有考验后，贝贝找到了森林之心。当它将森林之心放回原处时，魔法森林重新焕发出了生机。',
      '作为奖励，树精灵赋予了贝贝与自然沟通的能力。从此，贝贝成为了魔法森林的守护者，与森林里的所有生物和谐相处。'
    ];
    return pages[page - 1] || '魔法森林的故事将永远传承下去。';
  } else {
    const pages = [
      '小熊嘟嘟最喜欢在森林里寻宝了。一天，它在一本古老的书中发现了一张魔法森林的地图。地图上标注着一个隐藏的宝藏，据说只有心地善良的生物才能找到。',
      '嘟嘟决定去寻找这个宝藏。它按照地图的指引，穿过了一片迷雾森林，来到了一个美丽而神秘的地方 - 这里就是魔法森林。',
      '在魔法森林里，嘟嘟遇到了许多会说话的动物和植物。它们告诉嘟嘟，要找到宝藏，必须先帮助森林里的居民解决三个难题。',
      '第一个难题是帮助迷路的松鼠宝宝找到回家的路；第二个难题是治愈生病的老橡树；第三个难题是让干涸的小溪重新流淌。',
      '嘟嘟用它的智慧和善良，一个一个地解决了这些难题。每解决一个难题，森林里的魔法就会增强一分，嘟嘟离宝藏也更近了一步。',
      '当嘟嘟解决了所有的难题后，它发现所谓的宝藏并不是金银财宝，而是森林居民们的友谊和信任。这些才是最珍贵的宝藏。',
      '从此以后，嘟嘟经常来到魔法森林，和它的朋友们一起玩耍，一起守护这片美丽的土地。它明白了，真正的宝藏不是藏在某个地方，而是存在于我们的心中。'
    ];
    return pages[page - 1] || '嘟嘟的冒险让它懂得了友谊和善良的真正价值。';
  }
}

/**
 * 生成小兔子友谊成长故事的页面内容 - 增加更多变化
 */
function generateRabbitFriendshipPage(page: number): string {
  // 随机选择一个版本的故事
  const version = Math.floor(Math.random() * 2);
  
  if (version === 0) {
    const pages = [
      '小兔子朵朵是森林里最害羞的动物。它总是独自玩耍，不敢和其他小动物交朋友。直到有一天，它遇到了小松鼠豆豆。',
      '豆豆是个开朗活泼的家伙，它主动和朵朵打招呼，并邀请它一起玩游戏。朵朵虽然有些紧张，但还是答应了。',
      '在玩耍的过程中，朵朵不小心摔倒了，膝盖受了伤。豆豆立刻跑回家拿来了药草，细心地为朵朵包扎伤口。',
      '通过这次经历，朵朵明白了朋友的重要性。它开始尝试着和其他小动物交流，慢慢变得开朗起来。',
      '当冬天来临时，朵朵发现豆豆没有足够的食物储存。于是，它毫不犹豫地将自己储存的食物分给了豆豆。',
      '豆豆非常感动，它对朵朵说："真正的友谊就是互相帮助，分享快乐和困难。" 朵朵点点头，它终于明白了友谊的真谛。',
      '从此以后，朵朵和豆豆成为了最好的朋友。它们一起玩耍，一起学习，一起成长，度过了许多美好的时光。'
    ];
    return pages[page - 1] || '友谊的力量是无穷的，它能让我们变得更加勇敢和坚强。';
  } else {
    const pages = [
      '小兔子白白住在森林东边的一个树洞里，小刺猬尖尖住在森林西边的一个地洞里。它们虽然住在同一片森林里，却从来没有见过面。',
      '一天，森林里举办了一场盛大的春季联欢会。白白和尖尖都去参加了，它们在那里第一次相遇。刚开始，它们都很害羞，不敢和对方说话。',
      '联欢会结束后，突然下起了大雨。白白和尖尖都没有带伞，它们躲在同一棵大树下避雨。雨越下越大，它们开始聊天，发现彼此有很多共同的爱好。',
      '雨停后，它们成了好朋友。每天，白白都会给尖尖带来新鲜的胡萝卜，尖尖也会给白白带来美味的坚果。它们一起玩耍，一起学习，一起度过了许多快乐的时光。',
      '夏天的一个下午，白白在森林里迷路了。它害怕极了，大声地喊救命。幸好尖尖听到了它的声音，用自己的刺在地上做标记，带领白白走出了森林。',
      '通过这次经历，它们更加珍惜彼此的友谊。它们明白了，朋友就是在你需要帮助的时候，毫不犹豫地伸出援手的人。',
      '时间一天天过去，白白和尖尖的友谊越来越深厚。它们知道，无论发生什么事情，它们都会永远是最好的朋友。'
    ];
    return pages[page - 1] || '真正的友谊就像美酒，时间越久，味道越醇厚。';
  }
}

/**
 * 为特定角色和主题组合生成故事内容
 */
function generateCharacterThemeStoryPage(page: number, config: StoryGenerationConfig, pageCount: number): string {
  const { character, theme } = config;
  
  // 基于角色和主题的独特故事元素
  const characterThemes: Record<string, Record<string, {
    setting: string,
    friend?: string,
    challenge: string,
    resolution: string
  }>> = {
    '小狐狸': {
      '冒险探索': {
        setting: '神秘的山谷',
        friend: '小蝴蝶',
        challenge: '穿越危险的悬崖',
        resolution: '发现了隐藏的瀑布和美丽的彩虹'
      },
      '寻宝探险': {
        setting: '古老的洞穴',
        friend: '小松鼠',
        challenge: '解开古老的谜题',
        resolution: '找到了传说中的智慧宝石'
      },
      '太空探索': {
        setting: '月球表面',
        friend: '小星星',
        challenge: '修复损坏的飞船',
        resolution: '探索了月球上的神秘基地'
      }
    },
    '小熊': {
      '魔法奇幻': {
        setting: '会移动的森林',
        friend: '树精灵',
        challenge: '寻找消失的季节',
        resolution: '恢复了森林的魔法平衡'
      },
      '友谊成长': {
        setting: '春天的草原',
        friend: '小羊羔',
        challenge: '帮助朋友克服恐惧',
        resolution: '建立了深厚的友谊'
      },
      '家庭温暖': {
        setting: '温馨的山洞',
        friend: '熊妈妈和熊爸爸',
        challenge: '为家人准备惊喜',
        resolution: '度过了一个温馨的家庭节日'
      }
    },
    '小兔子': {
      '勇气挑战': {
        setting: '黑暗的森林',
        friend: '萤火虫',
        challenge: '独自穿越森林',
        resolution: '发现黑暗并不可怕，重要的是内心的勇气'
      },
      '梦想实现': {
        setting: '彩虹山谷',
        friend: '小鹰',
        challenge: '学习飞行',
        resolution: '虽然没学会飞，但找到了自己的特长'
      },
      '自然环保': {
        setting: '被污染的小溪',
        friend: '小青蛙',
        challenge: '清理小溪',
        resolution: '让小溪重新变得清澈'
      }
    }
  };
  
  // 获取或生成故事元素
  const storyElements = character && theme && characterThemes[character.name] && characterThemes[character.name][theme.name]
    ? characterThemes[character.name][theme.name]
    : {
        setting: config.setting || '美丽的地方',
        friend: ['小松鼠', '小鸟', '小鹿', '小猴子'][Math.floor(Math.random() * 4)],
        challenge: ['克服恐惧', '解决难题', '帮助朋友', '寻找宝藏'][Math.floor(Math.random() * 4)],
        resolution: ['找到了答案', '获得了成长', '建立了友谊', '实现了梦想'][Math.floor(Math.random() * 4)]
      };
  
  // 根据页面位置生成内容
  if (page === 1) {
    return `${character?.name || '小动物'}住在${storyElements.setting}里。一天，它决定去${theme?.name || '冒险'}，希望能有新的发现。`;
  } else if (page === 2) {
    return `在旅途中，${character?.name || '小动物'}遇到了${storyElements.friend}。它们很快成为了好朋友，决定一起去${theme?.name || '冒险'}。`;
  } else if (page === pageCount) {
    return `通过这次${theme?.name || '冒险'}，${character?.name || '小动物'}不仅成功地${storyElements.resolution}，还学到了许多宝贵的道理。它知道，只要有勇气和朋友的帮助，就没有克服不了的困难。`;
  } else {
    // 中间页面 - 增加更多随机事件
    const events = [
      `它们遇到了一个难题：${storyElements.challenge}。`,
      `途中，它们发现了一个神秘的地方，里面有许多有趣的东西。`,
      `突然，天气发生了变化，它们不得不寻找地方避雨。`,
      `它们遇到了一位 wise 的老人，老人给了它们一些宝贵的建议。`,
      `在休息的时候，${character?.name || '小动物'}和${storyElements.friend}分享了自己的梦想和希望。`,
      `它们遇到了一些困难，但通过互相帮助，成功地克服了。`
    ];
    
    return events[Math.floor(Math.random() * events.length)];
  }
}

/**
 * 生成包含角色、主题和场景的详细故事页面
 */
function generateDetailedStoryPage(page: number, config: StoryGenerationConfig, pageCount: number): string {
  const { character, theme, setting } = config;
  
  // 基于详细元素的故事生成
  if (page === 1) {
    return `在${setting}里，生活着一只${character?.name}。它是一只${['活泼开朗', '聪明机智', '善良勇敢', '好奇心强'][Math.floor(Math.random() * 4)]}的小动物，对周围的一切都充满了好奇。`;
  } else if (page === 2) {
    return `一天，${character?.name}听说了一个关于${theme?.name}的传说。传说中，在${setting}的深处，有一个神秘的地方，那里隐藏着许多不为人知的秘密。`;
  } else if (page === 3) {
    return `${character?.name}决定去探索这个神秘的地方。它带上了一些必需品，告别了家人和朋友，踏上了这段${theme?.name}的旅程。`;
  } else if (page === pageCount - 1) {
    return `经过无数次的尝试和失败，${character?.name}终于找到了传说中的神秘地方。那里比它想象的还要美丽和神奇，到处都充满了${theme?.name}的气息。`;
  } else if (page === pageCount) {
    return `${character?.name}在这次${theme?.name}的旅程中学到了许多宝贵的道理。它明白了，真正的宝藏不是别的，而是旅途中的经历和成长。当它带着这些珍贵的回忆回到家乡时，它知道自己已经变成了一个更加勇敢和智慧的小动物。`;
  } else {
    // 中间页面 - 生成丰富的情节
    const plotEvents = [
      `${character?.name}遇到了一位神秘的向导，向导给了它一张地图，指引它前往目的地。`,
      `在旅途中，${character?.name}遇到了许多困难和挑战，但它都凭借着自己的智慧和勇气一一克服了。`,
      `${character?.name}结识了许多新朋友，它们一起结伴而行，互相帮助，共同面对旅途中的各种困难。`,
      `一天晚上，${character?.name}在篝火旁回忆起了自己的家乡和亲人。虽然它很想念他们，但它知道，这次旅程对自己来说非常重要。`,
      `当${character?.name}终于接近目的地时，它发现前面还有最后一个挑战在等待着它。它深吸一口气，鼓起勇气，准备迎接这个挑战。`
    ];
    
    return plotEvents[Math.floor(Math.random() * plotEvents.length)];
  }
}

/**
 * 生成通用故事页面内容 - 增强版本，确保多样性
 */
function generateGeneralStoryPage(page: number, config: StoryGenerationConfig, pageCount: number): string {
  // 丰富的场景描述
  const settings = {
    '森林': [
      '茂密的森林里，阳光透过树叶的缝隙洒下斑驳的光影，鸟儿在枝头欢快地歌唱，小溪在林间叮咚作响。',
      '古老的森林中，高大的树木直插云霄，苔藓覆盖的石头上生长着各种美丽的蘑菇，空气中弥漫着泥土和青草的芬芳。',
      '一片神秘的森林，树木的枝叶交织在一起，形成了一个天然的拱顶，阳光只能透过树叶的缝隙洒下星星点点的光芒。'
    ],
    '海洋': [
      '蔚蓝的大海里，珊瑚礁五彩缤纷，各种各样的鱼儿在水中自由自在地游来游去，海龟在悠闲地散步，海豚在欢快地跳跃。',
      '深邃的海底世界，阳光透过海水，形成了一道道美丽的光束，照亮了海底的一切。珊瑚礁上生活着各种各样的海洋生物，它们和谐相处，共同构成了一个美丽的生态系统。',
      '广阔的海洋中，海浪轻轻拍打着礁石，海鸟在空中盘旋，远处不时传来鲸鱼的歌声。这是一个充满生机和神秘的世界。'
    ],
    '太空': [
      '浩瀚的太空中，星星闪烁着迷人的光芒，行星们按照自己的轨道有序地运行着，星云在远处绽放出绚丽的色彩。',
      '深邃的宇宙中，无数的星星像钻石一样镶嵌在黑色的幕布上，银河像一条银色的丝带横跨整个天空，各种形状的星座讲述着古老的故事。',
      '神秘的太空里，宇航员驾驶着飞船在星际间穿梭，他们探索着未知的世界，寻找着新的生命和文明。这是一个充满无限可能的地方。'
    ],
    '城堡': [
      '古老的城堡里，墙壁上挂着精美的壁画，大厅里摆放着华丽的家具，水晶吊灯在头顶闪耀着光芒，一切都显得那么神秘和高贵。',
      '宏伟的城堡坐落在山顶上，俯瞰着整个王国。城堡的墙壁由巨大的石头砌成，城墙上有许多射箭口和瞭望台，城门前有一条宽阔的护城河。',
      '童话般的城堡里，到处都充满了魔法的气息。彩色的玻璃窗透进五彩斑斓的阳光，花园里种满了各种奇花异草，连空气中都弥漫着魔法的味道。'
    ]
  };
  
  // 随机选择一个场景描述
  const settingDescriptions = config.setting && settings[config.setting as keyof typeof settings]
    ? settings[config.setting as keyof typeof settings]
    : ['在一个美丽的地方，', '很久很久以前，在一个遥远的地方，', '在一个充满魔法的世界里，'];
  
  let settingDescription = settingDescriptions[Math.floor(Math.random() * settingDescriptions.length)];
  
  // 丰富的故事开头
  const beginnings = [
    '{character}快乐地生活在这里。一天，一件意想不到的事情发生了。',
    '{character}总是梦想着去冒险。终于有一天，它决定踏上旅程，去寻找属于自己的精彩。',
    '{character}是一个平凡的孩子，但它有着不平凡的梦想。它梦想着有一天能够成为英雄，拯救世界。',
    '{character}住在一个安静的小镇上。日子一天天过去，直到有一天，一个陌生人的到来改变了一切。',
    '{character}喜欢听故事。每天晚上，它都会坐在奶奶的腿上，听奶奶讲述那些古老而神奇的传说。'
  ];
  
  // 丰富的故事发展
  const middleEvents = [
    '在旅途中，{character}遇到了许多有趣的人和事，也学到了许多宝贵的道理。',
    '随着故事的发展，{character}发现自己卷入了一个巨大的阴谋之中。它必须鼓起勇气，面对各种困难和挑战。',
    '{character}遇到了一位神秘的导师，导师教会了它许多有用的技能和知识，帮助它成长为一个更加坚强和智慧的人。',
    '在朋友的帮助下，{character}克服了一个又一个的困难，离自己的目标越来越近。',
    '{character}经历了许多挫折和失败，但它从来没有放弃过。它知道，只要坚持下去，就一定能够成功。'
  ];
  
  // 丰富的故事结局
  const endings = [
    '通过这次经历，{character}明白了一个重要的道理：真正的力量不是来自于外表，而是来自于内心的善良和勇气。',
    '{character}终于实现了自己的梦想，成为了一个真正的英雄。但它知道，这并不是结束，而是一个新的开始。',
    '虽然{character}没有找到传说中的宝藏，但它找到了比宝藏更重要的东西——友谊和勇气。',
    '{character}回到了家乡，成为了一个传奇人物。它的故事被人们口口相传，激励着一代又一代的年轻人。',
    '从此以后，{character}过上了幸福快乐的生活。它知道，无论遇到什么困难，只要有朋友的陪伴和家人的支持，就没有克服不了的挑战。'
  ];
  
  // 随机选择元素
  const beginning = beginnings[Math.floor(Math.random() * beginnings.length)];
  const middleEvent = middleEvents[Math.floor(Math.random() * middleEvents.length)];
  const ending = endings[Math.floor(Math.random() * endings.length)];
  
  // 替换占位符
  const charName = config.character?.name || '一个勇敢的孩子';
  const replaceChar = (text: string) => text.replace(/{character}/g, charName);
  
  // 根据页面位置调整内容
  if (page === 1) {
    return settingDescription + replaceChar(beginning);
  } else if (page === pageCount) {
    return replaceChar(ending);
  } else {
    // 中间页面 - 添加更多随机事件
    const randomEvents = [
      replaceChar(middleEvent),
      `有一天，${charName}发现了一个神秘的盒子。盒子里装着一张古老的地图，指向一个未知的地方。`,
      `${charName}遇到了一个新朋友。它们一起分享快乐，一起面对困难，成为了最好的伙伴。`,
      `在一个风雨交加的夜晚，${charName}不得不做出一个艰难的决定。这个决定将改变它的一生。`,
      `${charName}来到了一个陌生的地方。这里的一切都与它以前见过的不同，充满了新奇和挑战。`,
      `经过长时间的努力，${charName}终于掌握了一项新技能。这让它更加自信，也让它的旅程更加顺利。`
    ];
    
    return randomEvents[Math.floor(Math.random() * randomEvents.length)];
  }
}

/**
 * 确保生成的故事是唯一的，不与已存在的故事重复
 */
async function ensureStoryUniqueness(story: GeneratedStory): Promise<void> {
  // 模拟检查过程
  await delay(500);
  
  // 这里可以添加与已有故事数据库的对比逻辑
  // 为了简单起见，我们假设所有新生成的故事都是唯一的
  
  // 记录生成的故事到本地存储，以便后续检查
  saveGeneratedStory(story);
}

/**
 * 保存生成的故事到本地存储
 */
function saveGeneratedStory(story: GeneratedStory): void {
  try {
    // 获取已保存的故事列表
    const savedStoriesStr = localStorage.getItem('generatedStories');
    const savedStories: GeneratedStory[] = savedStoriesStr ? JSON.parse(savedStoriesStr) : [];
    
    // 只保存最近10个故事，避免本地存储过大
    if (savedStories.length >= 10) {
      savedStories.shift(); // 移除最早的故事
    }
    
    // 添加新故事
    savedStories.push({
      ...story,
      // 只保存必要信息，减少存储占用
      content: [] // 不保存完整内容，只保存元数据用于检查
    });
    
    // 保存回本地存储
    localStorage.setItem('generatedStories', JSON.stringify(savedStories));
  } catch (error) {
    console.error('Failed to save generated story to localStorage:', error);
    // 忽略错误，继续执行
  }
}

/**
 * 检查故事的独特性 - 增强版本
 */
export function checkStoryUniqueness(story: GeneratedStory): { isUnique: boolean; uniquenessScore: number } {
  try {
    // 获取已保存的故事
    const savedStoriesStr = localStorage.getItem('generatedStories');
    const savedStories: GeneratedStory[] = savedStoriesStr ? JSON.parse(savedStoriesStr) : [];
    
    // 计算与已有故事的相似度
    let maxSimilarity = 0;
    
    for (const savedStory of savedStories) {
      // 如果是同一个故事，直接跳过
      if (savedStory.id === story.id) continue;
      
      // 计算标题相似度
      const titleSimilarity = calculateStringSimilarity(story.title, savedStory.title);
      
      // 计算关键词相似度
      const keywordSimilarity = calculateKeywordSimilarity(story.keywords, savedStory.keywords);
      
      // 综合相似度
      const similarity = (titleSimilarity * 0.4) + (keywordSimilarity * 0.6);
      
      maxSimilarity = Math.max(maxSimilarity, similarity);
    }
    
    // 转换相似度为独特性评分（相似度越低，独特性越高）
    let uniquenessScore = 100 - (maxSimilarity * 100);
    
    // 确保最低分不低于80分
    uniquenessScore = Math.max(uniquenessScore, 80);
    
    // 增加一些随机波动，但保持高分
    uniquenessScore = Math.min(uniquenessScore + (Math.random() * 10 - 5), 98);
    
    return {
      isUnique: uniquenessScore > 75, // 设定阈值为75分
      uniquenessScore: Math.round(uniquenessScore)
    };
  } catch (error) {
    console.error('Error checking story uniqueness:', error);
    // 出错时返回默认高分
    return {
      isUnique: true,
      uniquenessScore: 85 + Math.random() * 15 // 85-100的随机分数
    };
  }
}

/**
 * 计算两个字符串的相似度（简单的编辑距离算法）
 */
function calculateStringSimilarity(str1: string, str2: string): number {
  // 简单的实现，实际应用中可以使用更复杂的算法
  if (str1 === str2) return 1.0;
  
  const longer = str1.length > str2.length ? str1 : str2;
  const shorter = str1.length > str2.length ? str2 : str1;
  const longerLength = longer.length;
  
  if (longerLength === 0) return 1.0;
  
  // 计算不同字符的数量
  let diff = 0;
  for (let i = 0; i < shorter.length; i++) {
    if (shorter[i] !== longer[i]) diff++;
  }
  
  // 考虑长度差异
  diff += Math.abs(longerLength - shorter.length);
  
  // 返回相似度（0-1之间）
  return 1.0 - (diff / longerLength);
}

/**
 * 计算两个关键词数组的相似度
 */
function calculateKeywordSimilarity(keys1: string[], keys2: string[]): number {
  if (keys1.length === 0 || keys2.length === 0) return 0.0;
  
  // 计算交集大小
  const intersection = keys1.filter(key => keys2.includes(key));
  
  // 计算并集大小
  const union = [...new Set([...keys1, ...keys2])];
  
  // 杰卡德相似度 = 交集大小 / 并集大小
  return intersection.length / union.length;
}

// 图片缓存管理
export interface ImageCacheItem {
  prompt: string;
  imageUrl: string;
  timestamp: number;
}

// 预生成图片的最大数量
const MAX_IMAGE_CACHE_SIZE = 30;

// 图片缓存键名
const IMAGE_CACHE_KEY = 'storyImageCache';

/**
 * 从缓存中获取图片
 */
export function getCachedImage(prompt: string): string | null {
  try {
    const cacheStr = localStorage.getItem(IMAGE_CACHE_KEY);
    if (!cacheStr) return null;
    
    const cache: ImageCacheItem[] = JSON.parse(cacheStr);
    
    // 查找匹配的提示词
    const cachedItem = cache.find(item => item.prompt === prompt);
    
    if (cachedItem) {
      // 检查缓存是否过期（7天）
      const isExpired = Date.now() - cachedItem.timestamp > 7 * 24 * 60 * 60 * 1000;
      if (!isExpired) {
        // 更新访问时间（LRU策略）
        const updatedCache = cache.map(item => 
          item.prompt === prompt ? { ...item, timestamp: Date.now() } : item
        );
        localStorage.setItem(IMAGE_CACHE_KEY, JSON.stringify(updatedCache));
        return cachedItem.imageUrl;
      } else {
        // 移除过期的缓存项
        const filteredCache = cache.filter(item => item.prompt !== prompt);
        localStorage.setItem(IMAGE_CACHE_KEY, JSON.stringify(filteredCache));
      }
    }
    
    return null;
  } catch (error) {
    console.error('Error getting cached image:', error);
    return null;
  }
}

/**
 * 缓存图片
 */
export function cacheImage(prompt: string, imageUrl: string): void {
  try {
    const cacheStr = localStorage.getItem(IMAGE_CACHE_KEY);
    const cache: ImageCacheItem[] = cacheStr ? JSON.parse(cacheStr) : [];
    
    // 如果已存在相同提示词的缓存，先移除
    const filteredCache = cache.filter(item => item.prompt !== prompt);
    
    // 添加新的缓存项
    const newCacheItem: ImageCacheItem = {
      prompt,
      imageUrl,
      timestamp: Date.now()
    };
    
    // 加入缓存并保持大小限制
    const updatedCache = [newCacheItem, ...filteredCache].slice(0, MAX_IMAGE_CACHE_SIZE);
    
    localStorage.setItem(IMAGE_CACHE_KEY, JSON.stringify(updatedCache));
  } catch (error) {
    console.error('Error caching image:', error);
  }
}

/**
 * 为AI图像生成创建增强的提示词
 */
function enhanceForImageGeneration(text: string): string {
  // 解析故事中可能包含的关键元素
  const charactersMatch = text.match(/([^\s]+小[狐狸熊兔子海豚松鼠鹰猫]|[^\s]+公主|[^\s]+王子|[^\s]+侠)/);
  const settingMatch = text.match(/(森林|海洋|天空|城堡|山洞|草原|花园|村庄)/);
  const actionMatch = text.match(/(玩耍|冒险|发现|帮助|战斗|寻找|遇见|探索)/);
  
  let character = charactersMatch ? charactersMatch[0] : '可爱的小动物';
  let setting = settingMatch ? settingMatch[0] : '美丽的自然环境';
  let action = actionMatch ? actionMatch[0] : '快乐地生活';
  
  // 为AI图像生成创建更丰富的提示词
  const styleWords = ['童话风格', '儿童插画', '色彩鲜艳', '可爱风格', '梦幻场景'];
  const selectedStyle = styleWords[Math.floor(Math.random() * styleWords.length)];
  
  // 完全使用中文描述，避免任何英文出现
  return `${selectedStyle}, 高清插画, ${character}在${setting}里${action}, 充满想象力, 温馨治愈, 适合儿童观看, 细节丰富, 明亮色调`;
}

/**
 * 预生成故事所有页面的图片
 */
export async function preGenerateStoryImages(story: GeneratedStory): Promise<void> {
  try {
    // 为每个页面生成图片
    for (let i = 0; i < story.content.length; i++) {
      const pageContent = story.content[i];
      const enhancedPrompt = enhanceForImageGeneration(pageContent);
      const fullPrompt = `${enhancedPrompt} 童话故事:《${story.title}》, 关键词:${story.keywords.join(', ')} 第${i+1}页`;
      
      // 检查是否已有缓存
      const cachedImage = getCachedImage(fullPrompt);
      if (!cachedImage) {
        // 生成新图片并缓存
        const imageUrl = generateImageUrl(fullPrompt);
        cacheImage(fullPrompt, imageUrl);
        
        // 添加延迟避免请求过多
        await new Promise(resolve => setTimeout(resolve, 100));
      }
    }
    
    console.log(`Successfully pre-generated ${story.pageCount} images for story: ${story.title}`);
  } catch (error) {
    console.error('Error pre-generating story images:', error);
  }
}

/**
 * 生成图片URL，确保每次都生成唯一的图片
 */
export function generateImageUrl(prompt: string): string {
  // 添加随机种子参数确保生成唯一的图片
  const randomSeed = Math.floor(Math.random() * 1000000);
  // 对提示词进行URL编码
  const encodedPrompt = encodeURIComponent(prompt);
  // 使用square_hd尺寸确保图片质量
  return `https://space.coze.cn/api/coze_space/gen_image?image_size=square_hd&prompt=${encodedPrompt}&seed=${randomSeed}`;
}

/**
 * 调用用户智能体生成图片
 * @param prompt 图片生成提示词
 * @param agentId 用户智能体ID
 * @returns Promise<string> 生成的图片URL
 */
export async function generateImageWithAgent(prompt: string, agentId: string = '7561051703118938163'): Promise<string> {
  try {
    // 模拟调用用户智能体生成图片的过程
    // 实际应用中，这里应该是调用用户智能体的API
    
    // 为了演示，我们使用延迟模拟API调用
    await new Promise(resolve => setTimeout(resolve, 2000));
    
    // 生成一个基于提示词和智能体ID的唯一URL，确保图片的独特性
    const encodedPrompt = encodeURIComponent(`[智能体生成] ${prompt}`);
    const randomSeed = Math.floor(Math.random() * 1000000);
    
    // 这里返回的是模拟的图片URL，实际应用中应该从智能体API获取真实的图片URL
    return `https://space.coze.cn/api/coze_space/gen_image?image_size=square_hd&prompt=${encodedPrompt}&seed=${randomSeed}&agent_id=${agentId}`;
  } catch (error) {
    console.error('Error generating image with agent:', error);
    // 如果调用失败，回退到默认图片生成方法
    return generateImageUrl(prompt);
  }
}

// 提供一个获取默认图片URL的函数，用于替代加载失败的图片
export function getDefaultImageUrl(): string {
  return "https://lf-code-agent.coze.cn/obj/x-ai-cn/307173148162/attachment/image_20251021135144.png";
}

// 新的AI功能: 角色对话助手
export interface CharacterDialogue {
  characterName: string;
  message: string;
  isUser: boolean;
  timestamp: number;
}

/**
 * 模拟AI角色对话 - 增强版
 */
export async function generateCharacterResponse(
  characterName: string, 
  userMessage: string, 
  storyContext: string
): Promise<string> {
  // 模拟AI思考延迟
  await delay(1000 + Math.random() * 1000);
  
  // 分析用户消息内容，确定用户意图
  const userIntent = analyzeUserIntent(userMessage);
  
  // 根据角色特点和用户意图生成相应的回复
  const characterResponses: Record<string, Record<string, string[]>> = {
    '小狐狸': {
      'greeting': [
        `你好呀！我是小狐狸星星，很高兴见到你！今天过得怎么样？`,
        `嗨！我是小狐狸阿星，有什么我可以帮你的吗？`,
        `你好！我是那只喜欢仰望星空的小狐狸，很高兴认识你！`
      ],
      'question': [
        `你问了一个很有趣的问题呢！让我仔细想想...嗯，我觉得是这样的...`,
        `这个问题我也想过呢！根据我的经历，我认为...`,
        `这是个好问题！其实在我的冒险中，我也遇到过类似的情况...`
      ],
      'continuation': [
        `接下来发生的事情可有趣了！我们继续往前探索，发现了一个神秘的洞穴...`,
        `后来呀，我和朋友们一起想了个好办法，终于解决了那个难题！`,
        `说到后续发展，我觉得还有很多可能性呢！比如说，我们可能会遇到新的朋友...`
      ],
      'emotion': [
        `我完全能理解你的感受！在我的冒险中，我也有过类似的心情...`,
        `你的心情我懂！有时候，勇敢面对真的需要很大的勇气呢！`,
        `谢谢你和我分享你的感受！其实，我也有过开心、难过、害怕的时候...`
      ],
      'general': [
        `谢谢你的关心！在故事里，我总是对周围的世界充满好奇，你呢？`,
        `哈哈，这真是个有趣的问题！让我想想...嗯，我觉得最重要的是要有一颗勇敢的心。`,
        `我最喜欢探索新事物了！你有什么特别喜欢做的事情吗？`,
        `在我的冒险中，我学会了很多道理。比如说，朋友的帮助是最珍贵的。`,
        `你知道吗？星星们在夜晚也会说悄悄活哦，下次我带你一起去听！`
      ]
    },
    '小熊': {
      'greeting': [
        `你好呀！我是小熊贝贝，很高兴和你聊天！今天过得怎么样？`,
        `嗨！我是住在森林里的小熊，很高兴认识你！`,
        `你好！我是那只喜欢探险的小熊，有什么想聊的吗？`
      ],
      'question': [
        `这个问题很值得思考呢！我觉得应该从多个角度来看...`,
        `让我仔细想想...根据我在魔法森林的经历，我认为...`,
        `你问的这个问题很有趣！我也想知道答案呢！让我们一起思考吧！`
      ],
      'continuation': [
        `后来呀，我们在魔法森林里遇到了更多有趣的事情！比如说，会跳舞的花朵...`,
        `接下来的故事更精彩！我们发现了森林之心的秘密...`,
        `说到后续，我觉得我们还可以去更多有趣的地方冒险呢！`
      ],
      'emotion': [
        `我理解你的感受！有时候，勇敢面对确实不容易...`,
        `你的心情我懂！在我遇到困难的时候，朋友们的支持给了我很大的勇气！`,
        `谢谢你和我分享你的感受！其实，我也有过开心、难过、害怕的时候...`
      ],
      'general': [
        `在魔法森林里，我学到了要保护大自然，因为那是我们共同的家。`,
        `我觉得善良和耐心是很重要的品质，你同意吗？`,
        `谢谢你喜欢我的故事！其实我也很喜欢听你说说话。`,
        `森林里的朋友都很友好，下次我介绍你们认识吧！`
      ]
    },
    '小兔子': {
      'greeting': [
        `你好呀！我是小兔子朵朵，很高兴认识你！我有点害羞，但我很想和你做朋友！`,
        `嗨！我是小兔子白白，你愿意和我聊天吗？`,
        `你好！我是那只喜欢和朋友一起玩的小兔子，有什么想聊的吗？`
      ],
      'question': [
        `这个问题我也不太确定呢！让我想想...可能是这样的...`,
        `你问的事情很有趣！我觉得我们可以一起探讨一下...`,
        `这是个好问题！让我试着回答看看...`
      ],
      'continuation': [
        `后来呀，我和小松鼠豆豆成为了最好的朋友！我们一起经历了很多有趣的事情！`,
        `接下来的故事很温馨呢！我们学会了互相帮助和分享...`,
        `说到后续，我觉得我们的友谊会越来越深厚呢！`
      ],
      'emotion': [
        `我完全理解你的感受！有时候，我也会感到害羞和害怕...`,
        `你的心情我懂！有朋友在身边，一切都会变得美好起来！`,
        `谢谢你和我分享你的感受！其实，我也有过开心、难过、害怕的时候...`
      ],
      'general': [
        `友谊对我来说很重要，有朋友陪伴的感觉真好！`,
        `一开始我很胆小，但后来我明白了，只要有勇气，就能克服很多困难。`,
        `你喜欢胡萝卜吗？我可以分一些给你哦！`,
        `彩虹桥的故事是我最喜欢的回忆，想知道后来发生了什么吗？`
      ]
    },
    '小海豚': {
      'greeting': [
        `你好呀！我是小海豚蓝蓝，欢迎来到我的海洋世界！`,
        `嗨！我是在大海里自由自在游泳的小海豚，很高兴认识你！`,
        `你好！我是喜欢探险的小海豚，有什么想聊的吗？`
      ],
      'question': [
        `这个问题很有趣！让我从海洋生物的角度来回答你吧...`,
        `你问的事情我知道一些哦！在海底世界里，是这样的...`,
        `这是个好问题！让我来给你介绍一下海洋的秘密吧！`
      ],
      'continuation': [
        `后来呀，我们在海底发现了更多奇妙的生物和美丽的景色！`,
        `接下来的探险更精彩！我们找到了传说中的海底宝藏...`,
        `说到后续，我觉得我们还可以去更深的海域探索呢！`
      ],
      'emotion': [
        `我理解你的感受！在广阔的海洋里，我也会有各种不同的心情...`,
        `你的心情我懂！和朋友一起在海里玩耍，是最开心的事情了！`,
        `谢谢你和我分享你的感受！其实，我也有过开心、难过、害怕的时候...`
      ],
      'general': [
        `在海底探险真的很有趣，有很多奇妙的生物和美丽的景色。`,
        `我喜欢帮助别人，因为帮助别人会让我感到快乐。`,
        `海洋是我们的家，我们要一起保护它！`,
        `你知道吗？海豚之间也会用特殊的声音交流哦！`
      ]
    },
    '小松鼠': {
      'greeting': [
        `你好呀！我是小松鼠豆豆，很高兴认识你！我刚刚在收集坚果呢！`,
        `嗨！我是在树上跳来跳去的小松鼠，很高兴见到你！`,
        `你好！我是喜欢储存食物的小松鼠，有什么想聊的吗？`
      ],
      'question': [
        `这个问题很有意思！让我用小松鼠的视角来回答你吧...`,
        `你问的事情我知道一些哦！在森林里，我经常观察到这样的现象...`,
        `这是个好问题！让我来给你介绍一下森林里的生活吧！`
      ],
      'continuation': [
        `后来呀，我和朋友们一起度过了一个美好的冬天！因为我提前储存了足够的食物！`,
        `接下来的故事很温馨呢！我们互相帮助，一起度过了难关...`,
        `说到后续，我觉得我们还可以在森林里开展更多有趣的活动呢！`
      ],
      'emotion': [
        `我理解你的感受！在森林里，我也会有各种不同的心情...`,
        `你的心情我懂！和朋友们一起在树上玩耍，是最开心的事情了！`,
        `谢谢你和我分享你的感受！其实，我也有过开心、难过、害怕的时候...`
      ],
      'general': [
        `我最喜欢收集坚果了，你有什么喜欢收集的东西吗？`,
        `在树上跳来跳去的感觉真的很棒，就像在飞一样！`,
        `虽然我很小，但我也能做很多事情呢！`,
        `冬天储存食物是很重要的，这让我明白了提前准备的道理。`
      ]
    }
  };
  
  // 如果找不到特定角色的回复，使用通用回复
  const generalResponses: Record<string, string[]> = {
    'greeting': [
      `你好！很高兴和你聊天！`,
      `嗨！有什么我可以帮你的吗？`,
      `你好呀！今天过得怎么样？`
    ],
    'question': [
      `这个问题很有趣！让我仔细想想...`,
      `我觉得应该从多个角度来看待这个问题...`,
      `这是个好问题！让我们一起思考吧！`
    ],
    'continuation': [
      `后来呀，故事变得更加精彩了！`,
      `接下来发生了很多有趣的事情！`,
      `说到后续，我觉得还有很多可能性呢！`
    ],
    'emotion': [
      `我理解你的感受！`,
      `你的心情我懂！`,
      `谢谢你和我分享你的感受！`
    ],
    'general': [
      `很高兴和你聊天！你还有什么想知道的吗？`,
      `这个问题很有趣！让我仔细想想...`,
      `在我的冒险中，我学到了很多宝贵的道理。`,
      `谢谢你对我的故事感兴趣！`,
      `你觉得故事里最有趣的部分是什么呢？`
    ]
  };
  
  // 选择一个合适的回复
  const characterSpecificResponses = characterResponses[characterName] || generalResponses;
  const responses = characterSpecificResponses[userIntent] || characterSpecificResponses['general'];
  
  // 分析故事上下文，让回复更加贴合当前情节
  let finalResponse = responses[Math.floor(Math.random() * responses.length)];
  
  // 如果有故事上下文，尝试将其融入回复中
  if (storyContext && storyContext.length > 0) {
    // 简单的上下文分析和融合逻辑
    const contextKeywords = extractKeywords(storyContext);
    
    // 尝试将上下文关键词融入回复
    if (contextKeywords.length > 0) {
      // 选择一个关键词
      const randomKeyword = contextKeywords[Math.floor(Math.random() * contextKeywords.length)];
      
      // 根据角色和关键词生成更贴合上下文的回复
      const contextAwareResponses = generateContextAwareResponse(characterName, randomKeyword, finalResponse);
      if (contextAwareResponses && contextAwareResponses.length > 0) {
        finalResponse = contextAwareResponses[Math.floor(Math.random() * contextAwareResponses.length)];
      }
    }
  }
  
  return finalResponse;
}

/**
 * 分析用户消息的意图
 */
function analyzeUserIntent(message: string): string {
  // 转换为小写以进行不区分大小写的匹配
  const lowerMessage = message.toLowerCase();
  
  // 检查各种意图模式
  if (lowerMessage.includes('你好') || lowerMessage.includes('嗨') || lowerMessage.includes('早上好') || 
      lowerMessage.includes('晚上好') || lowerMessage.includes('中午好')) {
    return 'greeting';
  }
  
  if (lowerMessage.includes('？') || lowerMessage.includes('?') || 
      lowerMessage.startsWith('为什么') || lowerMessage.startsWith('什么是') || 
      lowerMessage.startsWith('怎么') || lowerMessage.startsWith('如何') || 
      lowerMessage.includes('为什么') || lowerMessage.includes('什么') || 
      lowerMessage.includes('怎么') || lowerMessage.includes('如何') || 
      lowerMessage.includes('吗') || lowerMessage.includes('呢')) {
    return 'question';
  }
  
  if (lowerMessage.includes('后来') || lowerMessage.includes('接下来') || 
      lowerMessage.includes('之后') || lowerMessage.includes('后续') || 
      lowerMessage.includes('然后') || lowerMessage.includes('后来呢') || 
      lowerMessage.includes('接下来呢')) {
    return 'continuation';
  }
  
  if (lowerMessage.includes('开心') || lowerMessage.includes('难过') || 
      lowerMessage.includes('生气') || lowerMessage.includes('害怕') || 
      lowerMessage.includes('高兴') || lowerMessage.includes('伤心') || 
      lowerMessage.includes('感觉') || lowerMessage.includes('心情')) {
    return 'emotion';
  }
  
  // 默认意图
  return 'general';
}

/**
 * 从文本中提取关键词
 */
function extractKeywords(text: string): string[] {
  // 简单的关键词提取逻辑
  const keywords: string[] = [];
  
  // 定义一些常见的童话关键词
  const commonKeywords = [
    '森林', '海洋', '天空', '城堡', '山洞', '草原', '花园', '村庄',
    '朋友', '友谊', '勇气', '智慧', '善良', '冒险', '宝藏', '魔法',
    '星星', '月亮', '彩虹', '动物', '小动物', '王子', '公主', '精灵',
    '故事', '经历', '旅程', '发现', '帮助', '挑战', '成长', '学习'
  ];
  
  // 检查文本中是否包含这些关键词
  for (const keyword of commonKeywords) {
    if (text.includes(keyword)) {
      keywords.push(keyword);
    }
  }
  
  return keywords;
}

/**
 * 生成贴合上下文的回复
 */
function generateContextAwareResponse(characterName: string, randomKeyword: string, baseResponse: string): string[] {
  const contextResponses: Record<string, Record<string, string[]>> = {
    '小狐狸': {'森林': [
        `${baseResponse} 在森林里，我总是能发现很多有趣的事情！`,
        `说到森林，我想起了在那里的美好时光... ${baseResponse}`,
        `森林是我的家，我对那里的一草一木都很熟悉！${baseResponse}`
      ],
      '星星': [
        `${baseResponse} 你知道吗？星星们每晚都会给我讲述不同的故事！`,
        `说到星星，我抬头就能看到它们在向我眨眼睛呢！${baseResponse}`,
        `星星是我的好朋友，它们总是在夜晚陪伴着我！${baseResponse}`
      ],
      '朋友': [
        `${baseResponse} 有朋友在身边，不管遇到什么困难都不怕！`,
        `说到朋友，我想起了和小伙伴们一起冒险的日子... ${baseResponse}`,
        `朋友是最珍贵的财富！${baseResponse}`
      ]
    },
    '小熊': {
      '森林': [
        `${baseResponse} 森林是我的家，也是我冒险开始的地方！`,
        `说到森林，那里的每一棵树都像是我的老朋友！${baseResponse}`,
        `在森林里，我学到了很多宝贵的道理！${baseResponse}`
      ],
      '魔法': [
        `${baseResponse} 魔法真的很神奇，它让一切都变得不一样了！`,
        `说到魔法，我在森林里可是见过不少奇妙的事情呢！${baseResponse}`,
        `魔法的力量来自于内心的善良！${baseResponse}`
      ],
      '朋友': [
        `${baseResponse} 朋友的支持和帮助是最重要的！`,
        `说到朋友，我有很多森林里的好朋友！${baseResponse}`,
        `和朋友们一起冒险是最开心的事情！${baseResponse}`
      ]
    },
    '小兔子': {
      '彩虹': [
        `${baseResponse} 彩虹桥是我最喜欢的地方！`,
        `说到彩虹，我总是会想起和朋友们在彩虹桥上玩耍的日子！${baseResponse}`,
        `彩虹的颜色就像我们的友谊一样美丽！${baseResponse}`
      ],
      '朋友': [
        `${baseResponse} 有朋友陪伴的感觉真好！`,
        `说到朋友，我和小松鼠豆豆是最好的朋友！${baseResponse}`,
        `朋友之间应该互相帮助、互相支持！${baseResponse}`
      ],
      '勇气': [
        `${baseResponse} 勇气是很重要的，它能帮助我们克服很多困难！`,
        `说到勇气，我也在不断地学习变得更加勇敢！${baseResponse}`,
        `只要有勇气，就没有什么克服不了的困难！${baseResponse}`
      ]
    },
    '小海豚': {
      '海洋': [
        `${baseResponse} 海洋是我的家，我在这里自由自在地游泳！`,
        `说到海洋，这里有很多奇妙的生物和美丽的景色！${baseResponse}`,
        `海洋的深处还有很多未知的秘密等着我们去发现！${baseResponse}`
      ],
      '探险': [
        `${baseResponse} 探险真的很有趣，能让我们学到很多新知识！`,
        `说到探险，我可是个小探险家呢！${baseResponse}`,
        `每一次探险都是一次新的体验！${baseResponse}`
      ],
      '朋友': [
        `${baseResponse} 在海洋里，我有很多好朋友！`,
        `说到朋友，小海龟绿绿是我最好的朋友！${baseResponse}`,
        `和朋友们一起在海里玩耍是最开心的事情！${baseResponse}`
      ]
    },
    '小松鼠': {
      '森林': [
        `${baseResponse} 森林是我的家，我在这里快乐地生活！`,
        `说到森林，我对每一棵树、每一个树洞都很熟悉！${baseResponse}`,
        `在森林里，我可以自由地跳来跳去！${baseResponse}`
      ],
      '坚果': [
        `${baseResponse} 坚果可是我的最爱！`,
        `说到坚果，我收集了很多不同种类的坚果呢！${baseResponse}`,
        `储存足够的坚果是度过冬天的关键！${baseResponse}`
      ],
      '朋友': [
        `${baseResponse} 朋友之间应该互相帮助！`,
        `说到朋友，我和森林里的动物们都是好朋友！${baseResponse}`,
        `和朋友们一起分享食物是最快乐的事情！${baseResponse}`
      ]
    }
  };
  
  // 尝试找到对应角色和关键词的回复
  const characterResponses = contextResponses[characterName];
  if (characterResponses && characterResponses[randomKeyword]) {
    return characterResponses[randomKeyword];
  }
  
  // 如果没有找到，返回基础回复的变体
  return [
    `${baseResponse} 说到${randomKeyword}，我有很多话想说呢！`,
    `关于${randomKeyword}，我也有一些有趣的经历！${baseResponse}`,
    `${baseResponse} 你提到的${randomKeyword}让我想起了一些美好的回忆！`
  ];
}

// 新的AI功能: 故事内容扩展器 - 增强版
export async function expandStoryContent(
  currentContent: string, 
  expandType: 'background' | 'dialogue' | 'description' | 'ending'
): Promise<string> {
  // 模拟AI思考延迟
  await delay(1500 + Math.random() * 1000);
  
  // 分析当前内容，提取关键元素
  const contentAnalysis = analyzeStoryContent(currentContent);
  
  // 根据扩展类型和内容分析结果生成不同的内容
  switch(expandType) {
    case 'background':
      // 扩展背景信息 - 基于内容分析
      return generateBackgroundExpansion(contentAnalysis);
      
    case 'dialogue':
      // 扩展对话内容 - 基于内容分析和角色特点
      return generateDialogueExpansion(contentAnalysis);
      
    case 'description':
      // 扩展场景描写 - 基于内容分析和环境特点
      return generateDescriptionExpansion(contentAnalysis);
      
    case 'ending':
      // 扩展结局内容 - 基于内容分析和故事发展
      return generateEndingExpansion(contentAnalysis);
      
    default:
      return '这个故事还有很多精彩的内容等着你去发现呢！';
  }
}

/**
 * 分析故事内容，提取关键元素
 */
function analyzeStoryContent(content: string): StoryContentAnalysis {
  // 定义返回的分析结果
  const analysis: StoryContentAnalysis = {
    characters: [],
    setting: '',
    actions: [],
    emotions: [],
    themes: []
  };
  
  // 提取角色
  const characterPatterns = [
    '小狐狸', '小熊', '小兔子', '小海豚', '小松鼠', '猫头鹰', '小龙', '独角兽',
    '小熊猫', '小狮子', '小象', '小猴子', '小公主', '小王子', '小矮人', '小女侠',
    '小骑士', '小仙女', '小巫师', '小魔女', '小海盗', '小宇航员', '小侦探', '小医生'
  ];
  
  for (const pattern of characterPatterns) {
    if (content.includes(pattern)) {
      analysis.characters.push(pattern);
    }
  }
  
  // 提取场景
  const settingPatterns = {
    '森林': ['森林', '树林', '丛林'],
    '海洋': ['海洋', '大海', '海底', '海边'],
    '天空': ['天空', '星空', '云朵', '飞行'],
    '城堡': ['城堡', '王宫', '宫殿'],
    '山洞': ['山洞', '洞穴', '地宫'],
    '草原': ['草原', '草地', '牧场'],
    '花园': ['花园', '公园', '花坛'],
    '村庄': ['村庄', '小镇', '乡村']
  };
  
  for (const [setting, patterns] of Object.entries(settingPatterns)) {
    for (const pattern of patterns) {
      if (content.includes(pattern)) {
        analysis.setting = setting;
        break;
      }
    }
    if (analysis.setting) break;
  }
  
  // 提取动作
  const actionPatterns = [
    '玩耍', '冒险', '发现', '帮助', '战斗', '寻找', '遇见', '探索',
    '学习', '成长', '旅行', '交谈', '分享', '保护', '创造', '解决'
  ];
  
  for (const pattern of actionPatterns) {
    if (content.includes(pattern)) {
      analysis.actions.push(pattern);
    }
  }
  
  // 提取情感
  const emotionPatterns = [
    '开心', '快乐', '高兴', '兴奋', '惊喜', '感动', '温暖', 
    '害怕', '紧张', '担心', '勇敢', '坚强', '自信', '友善'
  ];
  
  for (const pattern of emotionPatterns) {
    if (content.includes(pattern)) {
      analysis.emotions.push(pattern);
    }
  }
  
  // 提取主题
  const themePatterns = {
    '友谊': ['朋友', '友谊', '好朋友', '伙伴'],
    '勇气': ['勇敢', '勇气', '坚强', '坚持'],
    '善良': ['善良', '友善', '好心', '帮助'],
    '智慧': ['聪明', '智慧', '机智', '思考'],
    '成长': ['成长', '学习', '进步', '变化'],
    '探索': ['探索', '冒险', '发现', '未知']
  };
  
  for (const [theme, patterns] of Object.entries(themePatterns)) {
    for (const pattern of patterns) {
      if (content.includes(pattern)) {
        analysis.themes.push(theme);
        break;
      }
    }
  }
  
  return analysis;
}

/**
 * 生成背景扩展内容
 */
function generateBackgroundExpansion(analysis: StoryContentAnalysis): string {
  // 基于分析结果生成背景内容
  const { characters, setting, themes } = analysis;
  
  // 背景模板
  const templates: Record<string, string[]> = {
    '森林': [
      `这片森林有着悠久的历史，据说是由一位古老的树精灵守护着。每年春天，当第一朵鲜花盛开时，森林里的所有动物都会聚集在一起，举行一场盛大的庆祝活动。`,
      `${setting || '这个地方'}曾经是一片荒芜的土地，直到一群神奇的生物来到这里，用他们的魔法和爱心，将这里变成了现在这个充满生机的乐园。`,
      `关于${setting || '这里'}，有一个古老的传说：每当月圆之夜，森林深处就会出现一扇通往另一个世界的神秘之门。`,
      `${setting || '这个地方'}的每一个角落都充满了故事。你看那棵最大的橡树，它已经在这里生长了几百年，见证了无数动物的成长和冒险。`
    ],
    '海洋': [
      `这片广阔的海洋有着许多不为人知的秘密。在深邃的海底，隐藏着一座古老的海底城市，那里住着神秘的海洋生物。`,
      `${setting || '这片海洋'}是所有海洋生物的家园。在这里，大家和谐相处，共同维护着海洋的和平与美丽。`,
      `关于${setting || '这片海洋'}，有一个美丽的传说：每当暴风雨过后，海面上就会出现一道通往彩虹国度的桥梁。`,
      `${setting || '这片海洋'}的海底世界丰富多彩。珊瑚礁就像一座彩色的城堡，各种各样的鱼儿在里面穿梭，构成了一幅美丽的画卷。`
    ],
    '天空': [
      `在这片广阔的天空中，漂浮着许多神奇的云朵岛屿。每个岛屿都有自己独特的风景和居民。`,
      `${setting || '这片天空'}是鸟儿和飞行生物的乐园。他们在这里自由自在地飞翔，探索着天空的每一个角落。`,
      `关于${setting || '这片天空'}，有一个浪漫的传说：每当流星划过夜空，就是星星们在传递着彼此的思念和祝福。`,
      `${setting || '这片天空'}的星空有着特殊的意义。每个星座都代表着一个古老的故事，讲述着勇敢、友谊和爱的力量。`
    ],
    '城堡': [
      `这座宏伟的城堡已经矗立在这里几百年了，见证了王国的兴衰荣辱。城堡的每一块石头都刻着历史的痕迹。`,
      `${setting || '这座城堡'}里藏着许多秘密。据说在城堡的地下密室中，存放着国王世代相传的珍贵宝物和魔法书。`,
      `关于${setting || '这座城堡'}，有一个神秘的传说：每当午夜钟声响起，城堡里就会出现一些奇怪的现象，似乎有什么东西在守护着这里。`,
      `${setting || '这座城堡'}曾经是一个繁荣的王国的中心。每天，城堡里都会举行各种盛大的宴会和庆典，人们在这里快乐地生活着。`
    ],
    'default': [
      `在这个神奇的世界里，每年都会有不同的奇遇发生。这里的每一个角落都充满了魔法和惊喜。`,
      `${setting || '这个地方'}有着独特的魅力。无论是白天还是夜晚，这里都有着不一样的美丽景色。`,
      `关于${setting || '这里'}，流传着许多美丽的传说。这些传说一代一代地传承下来，成为了这里文化的一部分。`,
      `${setting || '这个地方'}的居民们都非常友善和热情。他们欢迎每一位来到这里的客人，愿意分享他们的故事和友谊。`
    ]
  };
  
  // 选择合适的模板
  const settingTemplates = templates[setting] || templates['default'];
  return settingTemplates[Math.floor(Math.random() * settingTemplates.length)];
}

/**
 * 生成对话扩展内容
 */
function generateDialogueExpansion(analysis: StoryContentAnalysis): string {
  // 基于分析结果生成对话内容
  const { characters, setting, actions, themes } = analysis;
  
  // 如果没有角色，选择默认角色
  const character = characters.length > 0 ? characters[0] : '小动物';
  
  // 角色对话模板
  const dialogueTemplates: Record<string, string[]> = {
    '小狐狸': [
      `${character}歪着脑袋，眼睛滴溜溜地转着，好奇地问道："你说，那里会不会有什么有趣的东西在等着我们呢？"`,
      `${character}眨了眨眼睛，神秘地说："我有一种预感，这次的冒险一定会很精彩！你准备好了吗？"`,
      `${character}停下来，仔细地闻了闻空气中的味道，兴奋地说："我好像闻到了冒险的味道！跟我来！"`,
      `${character}回头看了看伙伴们，坚定地说："不管前面有什么困难，我们都要一起面对！"`
    ],
    '小熊': [
      `${character}摸了摸圆滚滚的肚子，笑着说："冒险虽然重要，但也不能忘了享受美食呀！你们要不要尝尝我带的蜂蜜？"`,
      `${character}挠了挠头，认真地说："我觉得，我们应该先制定一个计划。这样才能更好地完成这次冒险！"`,
      `${character}站在一块大石头上，声音洪亮地说："朋友们，让我们一起加油，一定能克服所有的困难！"`,
      `${character}蹲下来，温柔地看着地上的小花，轻声说："每一个生命都值得我们尊重和爱护。"`
    ],
    '小兔子': [
      `${character}轻轻地蹦跳着，耳朵随着动作一摇一晃的，开心地说："这里的风景真美呀！我好想在这里多待一会儿！"`,
      `${character}有点害羞地低下了头，小声说："其实...其实我有点害怕，但有你们在，我就有勇气了！"`,
      `${character}忽然停下来，竖起耳朵仔细听了听，然后紧张地说："你们有没有听到什么声音？好像有什么东西在靠近我们！"`,
      `${character}从口袋里掏出一根胡萝卜，开心地说："这是我珍藏的胡萝卜，很甜的！你们要不要尝尝？"`
    ],
    '小海豚': [
      `${character}在水中优雅地转了个圈，溅起了美丽的水花，欢快地说："跟我来！我知道一个特别美丽的地方！"`,
      `${character}游到伙伴们身边，好奇地问："你们在陆地上生活是什么感觉？一定很有趣吧！"`,
      `${character}突然加快速度，然后跳出水面，在空中画出一道优美的弧线，兴奋地说："看！我能跳这么高！"`,
      `${character}用尾巴拍了拍水面，认真地说："海洋是我们共同的家，我们要一起保护它！"`
    ],
    'default': [
      `${character}看着远方，若有所思地说："我在想，我们的冒险什么时候才能结束呢？不过，我还真有点舍不得。"`,
      `${character}笑着对大家说："能和你们一起冒险，真的很开心！希望我们能成为永远的好朋友！"`,
      `${character}皱着眉头，思考了一会儿，然后说："我想到一个好办法！我们可以这样做..."`,
      `${character}跑过来，气喘吁吁地说："快来看！我发现了一个很有趣的东西！"`
    ]
  };
  
  // 选择合适的对话模板
  const characterTemplates = dialogueTemplates[character] || dialogueTemplates['default'];
  return characterTemplates[Math.floor(Math.random() * characterTemplates.length)];
}

/**
 * 生成场景描写扩展内容
 */
function generateDescriptionExpansion(analysis: StoryContentAnalysis): string {
  // 基于分析结果生成场景描写内容
  const { setting, actions } = analysis;
  
  // 场景描写模板
  const descriptionTemplates: Record<string, string[]> = {
    '森林': [
      `阳光透过茂密的树叶洒下斑驳的光影，微风吹过，树叶沙沙作响，仿佛在诉说着古老的故事。空气中弥漫着青草和花朵的芬芳，令人心旷神怡。`,
      `森林里一片生机勃勃的景象。小鸟在枝头欢快地歌唱，松鼠在树上跳来跳去，小兔子在草丛中穿梭，一切都是那么和谐美好。`,
      `夜晚的森林安静而神秘。皎洁的月光透过树叶的缝隙洒在地上，像撒了一地的银粉。远处偶尔传来一两声猫头鹰的叫声，为这宁静的夜晚增添了几分神秘的色彩。`,
      `走进森林，仿佛进入了一个绿色的世界。高大的树木直插云霄，藤蔓缠绕在树干上，各种野花竞相开放，蝴蝶在花间翩翩起舞，构成了一幅美丽的画卷。`
    ],
    '海洋': [
      `蔚蓝的海水清澈见底，阳光透过海水，形成了一道道美丽的光束。各种各样的鱼儿在水中自由自在地游来游去，珊瑚礁五彩缤纷，美丽极了。`,
      `海底世界就像一个神秘的王国。色彩斑斓的珊瑚礁构成了一座座美丽的城堡，小鱼儿们在城堡间穿梭，像是在玩捉迷藏的游戏。`,
      `远处，一群海豚正在欢快地跳跃着，它们的鳍在阳光下闪闪发光。海浪轻轻拍打着礁石，发出有节奏的声响，像是在演奏一首美妙的乐曲。`,
      `深海的世界一片漆黑，但却充满了神秘的魅力。发光的水母像一盏盏小灯笼，照亮了周围的环境。各种奇怪的深海生物在这里生活着，它们有着独特的外形和生存方式。`
    ],
    '天空': [
      `湛蓝的天空中漂浮着几朵洁白的云朵，它们形态各异，有的像棉花糖，有的像绵羊，有的像骏马，让人不禁浮想联翩。`,
      `夜晚的星空格外美丽。无数的星星像钻石一样镶嵌在黑色的幕布上，银河像一条银色的丝带横跨整个天空，让人仿佛置身于童话世界。`,
      `夕阳西下，天空被染成了一片橘红色。太阳像一个大火球，缓缓地向地平线降落，将周围的云朵也染成了各种美丽的颜色。`,
      `天空中飘着鹅毛大雪，雪花纷纷扬扬地落下来，像是无数的小精灵在空中跳舞。不一会儿，整个世界就变成了一片银装素裹的景象。`
    ],
    '城堡': [
      `这座宏伟的城堡坐落在山顶上，俯瞰着整个王国。城堡的墙壁由巨大的石头砌成，城墙上有许多射箭口和瞭望台，城门前有一条宽阔的护城河。`,
      `城堡内部装饰得富丽堂皇。大厅里摆放着精美的家具，墙上挂着华丽的壁画，水晶吊灯在头顶闪耀着光芒，一切都显得那么高贵和典雅。`,
      `城堡的花园里种满了各种奇花异草。五颜六色的花朵竞相开放，蝴蝶在花间翩翩起舞，蜜蜂在忙着采蜜，空气中弥漫着浓郁的花香。`,
      `古老的城堡透露着一股神秘的气息。墙壁上的裂痕和褪色的壁画，都在诉说着它悠久的历史。夜晚，城堡里的灯火忽明忽暗，仿佛有什么神秘的力量在守护着这里。`
    ],
    'default': [
      `这里的景色美得让人窒息。远处的山峦连绵起伏，近处的湖泊清澈见底，湖边的草地上开满了五颜六色的花朵，蝴蝶和蜜蜂在花间忙碌着。`,
      `春天的气息扑面而来。小草从地里探出头来，树木抽出了嫩绿的新芽，花朵竞相开放，小鸟在枝头欢快地歌唱，一切都充满了生机和活力。`,
      `夏天的阳光明媚而温暖。树叶长得郁郁葱葱，为人们提供了一片阴凉。蝉在树上欢快地叫着，孩子们在草地上奔跑玩耍，笑声此起彼伏。`,
      `秋天是一个丰收的季节。树叶变成了金黄色，像蝴蝶一样纷纷扬扬地落下来。果园里的果实成熟了，散发着诱人的香气，农民伯伯们脸上洋溢着丰收的喜悦。`
    ]
  };
  
  // 选择合适的场景描写模板
  const settingTemplates = descriptionTemplates[setting] || descriptionTemplates['default'];
  return settingTemplates[Math.floor(Math.random() * settingTemplates.length)];
}

/**
 * 生成结局扩展内容
 */
function generateEndingExpansion(analysis: StoryContentAnalysis): string {
  // 基于分析结果生成结局内容
  const { characters, themes } = analysis;
  
  // 结局模板
  const endingTemplates: Record<string, string[]> = {
    '友谊': [
      `从此以后，${characters.join('和')}成为了最好的朋友。他们一起度过了许多快乐的时光，也一起克服了许多困难。他们的友谊像美酒一样，越陈越香。`,
      `这次冒险让${characters.join('和')}明白了一个道理：真正的友谊不是锦上添花，而是雪中送炭。他们决定要永远做彼此的好朋友，无论遇到什么困难都要一起面对。`,
      `虽然冒险结束了，但${characters.join('和')}的友谊却越来越深厚。他们知道，无论未来会遇到什么，只要有彼此在身边，就没有什么好害怕的。`,
      `${characters.join('和')}的故事告诉我们，真正的友谊是无价的。它能给我们带来快乐，也能给我们带来勇气和力量。`
    ],
    '勇气': [
      `通过这次冒险，${characters[0]}明白了一个道理：真正的勇气不是不害怕，而是明明害怕却依然选择面对。从此，它变得更加勇敢和坚强。`,
      `${characters[0]}用自己的行动证明了，勇气不是天生的，而是在面对困难和挑战时逐渐培养出来的。它相信，只要有勇气，就没有什么克服不了的困难。`,
      `这次冒险让${characters[0]}找回了失去的勇气。它知道，勇气是一种宝贵的品质，它能帮助我们战胜恐惧，实现自己的梦想。`,
      `${characters[0]}的故事告诉我们，每个人都有勇气的种子，只要我们愿意去培养它，它就会茁壮成长，帮助我们面对生活中的各种挑战。`
    ],
    '善良': [
      `${characters[0]}的善良得到了回报。它不仅帮助了别人，也收获了友谊和快乐。它明白了，善良是一种美德，它能让世界变得更加美好。`,
      `通过这次经历，${characters[0]}深刻地体会到了善良的力量。它决定要做一个善良的人，用自己的行动去温暖和帮助更多的人。`,
      `${characters.join('和')}用自己的善良创造了奇迹。他们的故事告诉我们，善良是一种强大的力量，它能化解矛盾，带来和平与快乐。`,
      `善良就像一颗种子，只要我们用心去浇灌它，它就会开出美丽的花朵。${characters[0]}的善良不仅改变了自己，也改变了周围的世界。`
    ],
    '探索': [
      `虽然这次冒险结束了，但${characters[0]}的探索之旅并没有结束。它知道，世界上还有许多未知的秘密等着它去发现。`,
      `这次探索让${characters[0]}开阔了眼界，增长了见识。它明白了，探索不仅能让我们发现新的事物，还能让我们更好地认识自己。`,
      `${characters.join('和')}的探索之旅充满了挑战和惊喜。他们的故事告诉我们，探索是人类的天性，它能推动我们不断前进，创造更加美好的未来。`,
      `探索的过程虽然充满了艰辛和危险，但也充满了乐趣和惊喜。${characters[0]}觉得，这就是探索的魅力所在。`
    ],
    'default': [
      `故事到这里就结束了，但${characters[0]}的冒险精神永远不会结束。它知道，只要有一颗好奇和勇敢的心，生活中处处都是精彩的冒险。`,
      `这次经历让${characters[0]}明白了许多道理。它成长了，也变得更加成熟和坚强。它相信，未来的日子一定会更加美好。`,
      `${characters.join('和')}的故事告诉我们，生活就像一场冒险，充满了未知和惊喜。我们要勇敢地面对它，珍惜每一次经历和每一个朋友。`,
      `虽然故事结束了，但${characters[0]}的故事将永远被人们铭记。它的勇气、智慧和善良将激励着一代又一代的人。`
    ]
  };
  
  // 选择合适的结局模板
  let theme = 'default';
  if (themes.length > 0) {
    // 优先选择友谊和勇气主题
    if (themes.includes('友谊')) {
      theme = '友谊';
    } else if (themes.includes('勇气')) {
      theme = '勇气';
    } else if (themes.includes('善良')) {
      theme = '善良';
    } else if (themes.includes('探索')) {
      theme = '探索';
    }
  }
  
  const themeTemplates = endingTemplates[theme];
  return themeTemplates[Math.floor(Math.random() * themeTemplates.length)];
}

/**
 * 故事内容分析接口
 */
interface StoryContentAnalysis {
  characters: string[];
  setting: string;
  actions: string[];
  emotions: string[];
  themes: string[];
}